{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 量子神经网络的贫瘠高原效应\n",
    "\n",
    "\n",
    "<em> Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. </em>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 概览\n",
    "\n",
    "在经典神经网络的训练中，基于梯度的优化方法不仅仅会遇到局部最小值的问题，同时还要面对鞍点等附近梯度近似于零的几何结构。相对应的，在量子神经网络中也存在着一种**贫瘠高原效应**（barren plateaus）。这个奇特的现象首先是由 McClean et al. 在 2018 年发现 [[1]](https://arxiv.org/abs/1803.11173)。简单来说，就是当你选取的随机电路结构满足一定复杂程度时优化曲面（optimization landscape）会变得很平坦，从而导致基于梯度下降的优化方法很难找到全局最小值。对于大多数的变分量子算法（VQE等），这个现象意味着当量子比特数量越来越多时，选取随机结构的电路有可能效果并不好。这会让你设计的损失函数所对应的优化曲面变成一个巨大的高原，让从而导致量子神经网络的训练愈加困难。你随机找到的初始值很难逃离这个高原，梯度下降收敛速度会很缓慢。\n",
    "\n",
    "![BP-fig-barren](./figures/BP-fig-barren-cn.png)\n",
    "\n",
    "图片由 [Gradient Descent Viz](https://github.com/lilipads/gradient_descent_viz) 生成\n",
    "\n",
    "\n",
    "基于梯度变化对这类变分量子算法训练的影响，我们在量桨（Paddle Quantum）平台提供了梯度分析工具模块，辅助用户对 QML 模型进行诊断，便于贫瘠高原等问题的研究。\n",
    "\n",
    "本教程主要讨论如何在量桨（Paddle Quantum）平台上展示贫瘠高原现象，以及如何使用梯度分析工具对用户自定义量子神经网络中的参数梯度进行分析。其中并不涉及任何算法创新，但能提升读者对于量子神经网络训练中梯度问题的认识。\n",
    "\n",
    "首先我们先引入必要的 library 和 package：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-02T12:20:39.463025Z",
     "start_time": "2021-03-02T12:20:36.336398Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\openfermion\\hamiltonians\\hartree_fock.py:11: DeprecationWarning: Please use `OptimizeResult` from the `scipy.optimize` namespace, the `scipy.optimize.optimize` namespace is deprecated.\n",
      "  from scipy.optimize.optimize import OptimizeResult\n"
     ]
    }
   ],
   "source": [
    "# 忽略 waring 输出\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "# 需要用的包\n",
    "import time\n",
    "import numpy as np\n",
    "from math import pi\n",
    "import paddle\n",
    "from paddle_quantum.state import zero_state\n",
    "from paddle_quantum.ansatz import Circuit\n",
    "from paddle_quantum.linalg import dagger\n",
    "# 画图工具\n",
    "from matplotlib import pyplot as plt \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 随机的网络结构\n",
    "\n",
    "这里我们按照原作者 McClean (2018) [[1]](https://arxiv.org/abs/1803.11173) 论文中提及的类似方法搭建如下随机电路：\n",
    "\n",
    "![BP-fig-Barren_circuit](./figures/BP-fig-Barren_circuit.png)\n",
    "\n",
    "首先作用在所有量子比特上绕布洛赫球的 Y-轴旋转 $\\pi/4$。\n",
    "\n",
    "其余的结构加起来构成一个模块（Block）, 每个模块共分为两层：\n",
    "\n",
    "- 第一层搭建随机的旋转门, 其中 $R_{\\ell,n} \\in \\{R_x, R_y, R_z\\}$。下标 $\\ell$ 表示处于第 $\\ell$ 个重复的模块， 上图中 $\\ell =1$。第二个下标 $n$ 表示作用在第几个量子比特上。\n",
    "- 第二层由 CZ 门组成，作用在每两个相邻的量子比特上。\n",
    "\n",
    "在量桨中, 我们可以这么搭建。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-02T12:20:39.972053Z",
     "start_time": "2021-03-02T12:20:39.962259Z"
    }
   },
   "outputs": [],
   "source": [
    "def rand_circuit(target, num_qubits, theta=None):\n",
    "    # 初始化量子电路\n",
    "    cir = Circuit(num_qubits)\n",
    "    \n",
    "    # 固定角度的 Ry 旋转门\n",
    "    cir.ry(param=pi / 4)\n",
    "\n",
    "    # ============== 第一层 ==============\n",
    "    # target是一个随机的数组,用来帮助我们抽取随机的单比特门 \n",
    "    for i in range(num_qubits):\n",
    "        if target[i] == 0:\n",
    "            cir.rz(i, param=theta[i] if theta is not None else theta)\n",
    "        elif target[i] == 1:\n",
    "            cir.ry(i, param=theta[i] if theta is not None else theta)\n",
    "        else:\n",
    "            cir.rx(i, param=theta[i] if theta is not None else theta)\n",
    "            \n",
    "    # ============== 第二层 ==============\n",
    "    # 搭建两两相邻的 CZ 门\n",
    "    for i in range(num_qubits - 1):\n",
    "        cir.cz([i, i + 1])\n",
    "        \n",
    "    return cir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 损失函数与优化曲面 \n",
    "\n",
    "当我们确定了电路的结构之后，我们还需要定义一个损失函数（loss function）来确定优化曲面。按照原作者 McClean (2018) [[1]](https://arxiv.org/abs/1803.11173) 论文中提及的，我们采用 VQE算法中常用的损失函数：\n",
    "\n",
    "$$\n",
    "\\mathcal{L}(\\boldsymbol{\\theta})= \\langle0| U^{\\dagger}(\\boldsymbol{\\theta})H U(\\boldsymbol{\\theta}) |0\\rangle,\n",
    "\\tag{1}\n",
    "$$\n",
    "\n",
    "其中的酉矩阵 $U(\\boldsymbol{\\theta})$ 就是我们上一部分搭建的带有随机结构的量子神经网络。对于其中的哈密顿量 $H$ 我们不妨先取最简单的形式 $H = |00\\cdots 0\\rangle\\langle00\\cdots 0|$。设定好这些后，我们就可以从最简单的两个量子比特的情形开始采样了 -- 生成300组随机网络结构和不同的随机初始参数 $\\{\\theta_{\\ell,n}^{(i)}\\}_{i=1}^{300}$。每次计算梯度都是按照 VQE 的解析梯度公式计算关于 **第一个参数 $\\theta_{1,1}$** 的偏导数。然后统计得到的这300个梯度的平均值和方差。其中解析梯度的公式为：\n",
    "\n",
    "$$\n",
    "\\partial \\theta_{j} \n",
    "\\equiv \\frac{\\partial \\mathcal{L}}{\\partial \\theta_j}\n",
    "= \\frac{1}{2} \\big[\\mathcal{L}(\\theta_j + \\frac{\\pi}{2}) - \\mathcal{L}(\\theta_j - \\frac{\\pi}{2})\\big].\n",
    "\\tag{2}\n",
    "$$\n",
    "\n",
    "具体推导请参见：[arXiv:1803.00745](https://arxiv.org/abs/1803.00745)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-02T12:20:52.236108Z",
     "start_time": "2021-03-02T12:20:40.850822Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\fluid\\framework.py:1104: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  elif dtype == np.bool:\n",
      "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\tensor\\creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  if data.dtype == np.object:\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "主程序段总共运行了 2.7961888313293457 秒\n",
      "采样 300 个随机网络关于第一个参数梯度的均值是： -0.025778826\n",
      "采样 300 个随机网络关于第一个参数梯度的方差是： 0.11283756\n"
     ]
    }
   ],
   "source": [
    "# 超参数设置\n",
    "# np.random.seed(42)        # 固定 Numpy 的随机种子\n",
    "N = 2                     # 设置量子比特数量 \n",
    "samples = 300             # 设定采样随机网络结构的数量\n",
    "THETA_SIZE = N            # 设置参数 theta 的大小\n",
    "ITR = 1                   # 设置迭代次数\n",
    "LR = 0.2                  # 设定学习速率\n",
    "SEED = 1                  # 固定优化器中随机初始化的种子\n",
    "\n",
    "# 初始化梯度数值的寄存器\n",
    "grad_info = []\n",
    "\n",
    "# paddle.seed(SEED)\n",
    "\n",
    "class manual_gradient(paddle.nn.Layer):\n",
    "    \n",
    "    # 初始化一个可学习参数列表，并用 [0, 2*pi] 的均匀分布来填充初始值\n",
    "    def __init__(self, shape, param_attr=paddle.nn.initializer.Uniform(low=0.0, high=2*pi), dtype='float32'):\n",
    "        super(manual_gradient, self).__init__()\n",
    "        \n",
    "        # 将 Numpy array 转换成 Paddle 中的 Tensor\n",
    "        self.H = zero_state(N).data\n",
    "        \n",
    "    # 定义损失函数和前向传播机制    \n",
    "    def forward(self):\n",
    "        \n",
    "        # 初始化三个 theta 参数列表\n",
    "        theta_np = np.random.uniform(low=0., high=2*pi, size=(THETA_SIZE))\n",
    "        theta_plus_np = np.copy(theta_np) \n",
    "        theta_minus_np = np.copy(theta_np) \n",
    "        \n",
    "        # 修改用以计算解析梯度\n",
    "        theta_plus_np[0] += pi/2\n",
    "        theta_minus_np[0] -= pi/2\n",
    "        \n",
    "        # 将 Numpy array 转换成 Paddle 中的 Tensor\n",
    "        theta_plus = paddle.to_tensor(theta_plus_np)\n",
    "        theta_minus = paddle.to_tensor(theta_minus_np)\n",
    "        \n",
    "        # 生成随机目标，在 rand_circuit 中随机选取电路门\n",
    "        target = np.random.choice(3, N)      \n",
    "        \n",
    "        U_plus = rand_circuit(target, N, theta_plus).unitary_matrix()\n",
    "        U_minus = rand_circuit(target, N, theta_minus).unitary_matrix()\n",
    "\n",
    "        # 计算解析梯度\n",
    "        grad = paddle.real((dagger(U_plus) @ self.H @ U_plus)[0][0] - (dagger(U_minus) @ self.H @ U_minus)[0][0])/2  \n",
    "        \n",
    "        return grad\n",
    "\n",
    "# 定义主程序段\n",
    "def main():\n",
    "    \n",
    "    # 设置QNN的维度\n",
    "    sampling = manual_gradient(shape=[THETA_SIZE])\n",
    "\n",
    "    # 采样获得梯度信息\n",
    "    grad = sampling().numpy()   \n",
    "        \n",
    "    return grad\n",
    "\n",
    "\n",
    "# 记录运行时间\n",
    "time_start = time.time()\n",
    "\n",
    "# 开始采样\n",
    "for i in range(samples):\n",
    "    if __name__ == '__main__':\n",
    "        grad = main()\n",
    "        grad_info.append(grad)\n",
    "\n",
    "time_span = time.time() - time_start        \n",
    "print('主程序段总共运行了', time_span, '秒')\n",
    "print(\"采样\", samples, \"个随机网络关于第一个参数梯度的均值是：\", np.mean(grad_info))\n",
    "print(\"采样\", samples, \"个随机网络关于第一个参数梯度的方差是：\", np.var(grad_info))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 优化曲面的可视化\n",
    "\n",
    "接下来我们试着利用 Matplotlib来可视化这个优化曲面（optimization landscape）。在**两个量子比特**的情况下，我们只有两个参数 $\\theta_1$ 和 $\\theta_2$, 并且第二层的随机电路电路总共有9种情况。这个很容易画出来：\n",
    "\n",
    "![BP-fig-landscape2](./figures/BP-fig-landscape2.png)\n",
    "\n",
    "可以看到的是最后一张图中 $R_z$-$R_z$ 结构所展示出的平原结构是我们非常不想见到的。在这种情况下，我们不能收敛到理论最小值。如果你想自己试着画一些优化曲面，不妨参见以下代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-02T12:21:49.972769Z",
     "start_time": "2021-03-02T12:21:45.792119Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x345.6 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "主程序段总共运行了 1.4345674514770508 秒\n"
     ]
    }
   ],
   "source": [
    "time_start = time.time()\n",
    "N = 2\n",
    "\n",
    "# 设置图像比例 竖：横 = 0.3 \n",
    "fig = plt.figure(figsize=plt.figaspect(0.3))\n",
    "\n",
    "# 生成 x, y 轴上的点\n",
    "X = np.linspace(0, 2 * pi, 80)\n",
    "Y = np.linspace(0, 2 * pi, 80)\n",
    "\n",
    "# 生成 2D 网格 (mesh)\n",
    "xx, yy = np.meshgrid(X, Y)\n",
    "\n",
    "\n",
    "# 定义必要的逻辑门\n",
    "def rx(theta):\n",
    "    mat = np.array([[np.cos(theta/2), -1j * np.sin(theta/2)],\n",
    "                    [-1j * np.sin(theta/2), np.cos(theta/2)]])\n",
    "    return mat\n",
    "\n",
    "def ry(theta):\n",
    "    mat = np.array([[np.cos(theta/2), -1 * np.sin(theta/2)],\n",
    "                    [np.sin(theta/2), np.cos(theta/2)]])\n",
    "    return mat\n",
    "\n",
    "def rz(theta):\n",
    "    mat = np.array([[np.exp(-1j * theta/2), 0],\n",
    "                    [0, np.exp(1j * theta/2)]])\n",
    "    return mat\n",
    "\n",
    "def CZ():\n",
    "    mat = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, -1]])\n",
    "    return mat\n",
    "\n",
    "# ============= 第一张图 =============\n",
    "# 我们可视化第二层是 kron(Ry, Ry) 的情况\n",
    "ax = fig.add_subplot(1, 2, 1, projection='3d')\n",
    "\n",
    "# 向前传播计算损失函数：\n",
    "def cost_yy(para):\n",
    "    L1 = np.kron(ry(pi/4), ry(pi/4))\n",
    "    L2 = np.kron(ry(para[0]), ry(para[1]))\n",
    "    U = np.matmul(np.matmul(L1, L2), CZ())\n",
    "    H = np.zeros((2 ** N, 2 ** N))\n",
    "    H[0, 0] = 1\n",
    "    val = (U.conj().T @ H @ U).real[0][0]\n",
    "    return val\n",
    "\n",
    "# 画出图像\n",
    "Z = np.array([[cost_yy([x, y]) for x in X] for y in Y]).reshape(len(Y), len(X))\n",
    "surf = ax.plot_surface(xx, yy, Z, cmap='plasma')\n",
    "ax.set_xlabel(r\"$\\theta_1$\")\n",
    "ax.set_ylabel(r\"$\\theta_2$\")\n",
    "ax.set_title(\"Optimization Landscape for Ry-Ry Layer\")\n",
    "\n",
    "# ============= 第二张图 =============\n",
    "# 我们可视化第二层是 kron(Rx, Rz) 的情况\n",
    "ax = fig.add_subplot(1, 2, 2, projection='3d')\n",
    "\n",
    "\n",
    "def cost_xz(para):\n",
    "    L1 = np.kron(ry(pi/4), ry(pi/4))\n",
    "    L2 = np.kron(rx(para[0]), rz(para[1]))\n",
    "    U = np.matmul(np.matmul(L1, L2), CZ())\n",
    "    H = np.zeros((2 ** N, 2 ** N))\n",
    "    H[0, 0] = 1\n",
    "    val = (U.conj().T @ H @ U).real[0][0]\n",
    "    return val\n",
    "\n",
    "Z = np.array([[cost_xz([x, y]) for x in X] for y in Y]).reshape(len(Y), len(X))\n",
    "surf = ax.plot_surface(xx, yy, Z, cmap='viridis')\n",
    "ax.set_xlabel(r\"$\\theta_1$\")\n",
    "ax.set_ylabel(r\"$\\theta_2$\")\n",
    "ax.set_title(\"Optimization Landscape for Rx-Rz Layer\")\n",
    "\n",
    "\n",
    "plt.show()\n",
    "\n",
    "time_span = time.time() - time_start        \n",
    "print('主程序段总共运行了', time_span, '秒')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 梯度分析工具\n",
    "\n",
    "基于梯度在贫瘠高原等现象中的表现出的重要作用，我们在量桨平台开发了一个简单的梯度分析工具，辅助用户查看电路中各参数的梯度情况，方便对量子神经网络做后续研究。\n",
    "\n",
    "需要注意的是，我们使用梯度分析工具时仅需用户**单独定义传入的电路和损失函数，不需要用户自己写网络训练**，减少使用负担"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 应用 一：无监督学习\n",
    "\n",
    "对于该类情况，主要关注类似变分量子本征求解器（VQE）的变分量子算法。该类变分算法要优化的目标函数通常是量子电路关于哈密顿量 $H$ 的期望值，即 $O(\\theta) = \\left\\langle0\\dots 0\\right\\lvert U^{\\dagger}(\\theta)HU(\\theta) \\left\\lvert0\\dots 0\\right\\rangle$，这里的 $U(\\theta)$ 表示的就是参数化量子电路，其中 $\\theta = [\\theta_1, \\theta_2, \\dots, \\theta_n]$ 是电路中的可训练参数，$H$ 是哈密顿量。 \n",
    "\n",
    "这里我们就以 VQE 做代表，演示该梯度分析工具的用法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Paddle Quantum 实现\n",
    "\n",
    "首先导入该问题需要的包："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 需要用的包\n",
    "from paddle_quantum.qinfo import pauli_str_to_matrix, random_pauli_str_generator\n",
    "from paddle_quantum.hamiltonian import Hamiltonian\n",
    "# 导入梯度工具包\n",
    "from paddle_quantum.gradtool import random_sample, show_gradient, plot_loss_grad, show_gradient"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 定义量子电路\n",
    "\n",
    "接着，构造目标函数 $O(\\theta) = \\left\\langle00\\right\\lvert U^{\\dagger}(\\theta)HU(\\theta) \\left\\lvert00\\right\\rangle$ 中的参数化量子电路 $U(\\theta)$。这里我们还是采用上文中定义的随机电路。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 定义目标函数\n",
    "\n",
    "之后给出要优化的目标函数（这里需要注意的是，在梯度分析模块中我们是以 ``loss_func(circuit, *args)`` 的形式调用函数计算目标函数值的。这也就是说，第二个参数是可变参数，用户可以根据需要灵活的构造自己模型的目标函数形式）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 要优化的目标函数，其中参数分别是电路和哈密顿量\n",
    "def loss_func(circuit: Circuit, H: Hamiltonian) -> paddle.Tensor:\n",
    "    return circuit().expec_val(H, shots = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接着设置一些应用所需的参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 超参数设置\n",
    "# np.random.seed(1)        # 固定 Numpy 的随机种子\n",
    "N = 2                    # 设置量子比特数量 \n",
    "samples = 300             # 设定采样随机网络结构的数量\n",
    "THETA_SIZE = N            # 设置参数 theta 的大小  \n",
    "ITR = 120                 # 设置迭代次数\n",
    "LR = 0.1                  # 设定学习速率\n",
    "SEED = 2                  # 固定优化器中随机初始化的种子"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "随机生成参数化量子电路，以及哈密顿量信息列表。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ry(0.785)----Rx(0.557)----*--\n",
      "                            |  \n",
      "--Ry(0.785)----Rz(1.090)----z--\n",
      "                               \n",
      "Hamiltonian info:  -0.5460435438880067 X0\n",
      "-0.06715081059031625 Z1, Z0\n",
      "-0.7710366768893184 Z1, X0\n",
      "-0.7873104687630661 Z1, Y0\n",
      "0.9563406325371104 Y0\n",
      "0.8230280338420977 Y1\n",
      "-0.7909293184638813 Y0, Y1\n"
     ]
    }
   ],
   "source": [
    "# paddle.seed(SEED)\n",
    "target = np.random.choice(3, N)\n",
    "# 在 0 - 2*Pi 间随机生成各参数值\n",
    "cir = rand_circuit(target, N)\n",
    "print(cir)\n",
    "# 随机生成哈密顿量\n",
    "H_l = Hamiltonian(random_pauli_str_generator(N, terms=7))\n",
    "print('Hamiltonian info: ', H_l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``cir`` 和 ``H_l`` 就是要优化的目标函数 ``loss_func`` 所需的参数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "用户可以通过我们提供的梯度分析工具，查看电路中各参数梯度采样的结果。同时，可以根据需求在 ``single``, ``max``, 以及 ``random`` 三种模式间选择，其中 ``single`` 会返回电路多次采样后每个参数的平均值和方差， ``max`` 模式返回每轮采样中所有参数梯度最大值的均值和方差，``random`` 则是在每轮采样得到的各参数梯度中随机选择一个后计算均值和方差。\n",
    "\n",
    "我们首先对该电路采样 300 次，这里我们选择 ``single`` 模式，看看电路中每个可变参数梯度的平均值和方差，同时默认 ``param=0`` 表示我们查看第一个参数的梯度分布情况。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Sampling: 100%|###################################################| 300/300 [00:03<00:00, 83.25it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean of gradient for all parameters: \n",
      "theta 1 :  0.010323498\n",
      "theta 2 :  -0.023893388\n",
      "Variance of gradient for all parameters: \n",
      "theta 1 :  0.04497918\n",
      "theta 2 :  0.1173012\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "grad_mean_list, grad_variance_list = random_sample(cir, loss_func, samples, H_l, mode='single', param=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "用户如果想要查看该量子电路在训练过程中梯度和损失值的变化情况，还可以使用 ``plot_loss_grad`` 函数，辅助查看电路的训练效果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training:   0%|                                                             | 0/120 [00:00<?, ?it/s]c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\fluid\\framework.py:1104: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  elif dtype == np.bool:\n",
      "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\tensor\\creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  if data.dtype == np.object:\n",
      "Training: 100%|###################################################| 120/120 [00:01<00:00, 82.80it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_loss_grad(cir, loss_func, ITR, LR, H_l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如上图所示，可以看出 iteration 在几十次后损失函数的值就基本不发生变化了，而梯度也非常的接近 0。为了更直观的看到训练得到的最优解和理论值的差距，我们计算哈密顿量 ``H_l`` 的特征值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training: 100%|###################################################| 120/120 [00:01<00:00, 93.13it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最终的优化结果：  -1.431776\n",
      "实际的基态能量： -2.935288\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "loss, grad = show_gradient(cir, loss_func, ITR, LR, H_l)\n",
    "H_matrix = H_l.construct_h_matrix()\n",
    "\n",
    "print(\"最终的优化结果： \", loss[-1])\n",
    "print(\"实际的基态能量：\", np.linalg.eigh(H_matrix)[0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过对比可以看出，该电路训练得到的最优解和我们要得到的实际值之间还存在一定的差距。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 更多的量子比特\n",
    "\n",
    "由于在贫瘠高原效应中，梯度会随着量子比特数的增加呈指数级消失。所以我们可以进一步对比增加电路中量子比特的数量，看看会对我们的梯度带来什么影响  (这里我们采样时选择 ``max`` 模式，对参数列表中的最大值做计算)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Sampling: 100%|###################################################| 300/300 [00:03<00:00, 89.26it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean of max gradient\n",
      "0.7397743\n",
      "Variance of max gradient\n",
      "0.16580562\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Sampling:   0%|                                                             | 0/300 [00:00<?, ?it/s]c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\fluid\\framework.py:1104: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  elif dtype == np.bool:\n",
      "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\tensor\\creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  if data.dtype == np.object:\n",
      "Sampling: 100%|###################################################| 300/300 [00:07<00:00, 42.85it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean of max gradient\n",
      "0.5297382\n",
      "Variance of max gradient\n",
      "0.015179126\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Sampling:   0%|                                                             | 0/300 [00:00<?, ?it/s]c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\fluid\\framework.py:1104: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  elif dtype == np.bool:\n",
      "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\tensor\\creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  if data.dtype == np.object:\n",
      "Sampling: 100%|###################################################| 300/300 [00:10<00:00, 27.92it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean of max gradient\n",
      "0.23806638\n",
      "Variance of max gradient\n",
      "0.00466864\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Sampling:   0%|                                                             | 0/300 [00:00<?, ?it/s]c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\fluid\\framework.py:1104: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  elif dtype == np.bool:\n",
      "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\tensor\\creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  if data.dtype == np.object:\n",
      "Sampling: 100%|###################################################| 300/300 [00:14<00:00, 20.99it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean of max gradient\n",
      "0.3086849\n",
      "Variance of max gradient\n",
      "0.026925158\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEICAYAAABS0fM3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAacUlEQVR4nO3de7hcVX3/8ffHhCSAhFuCkoscsKEQKQoNAS/UPIJCQKEXKqFargr8fo3aqm1DaRFTqaCl/oLwexC0KiCXgFJTjAZFqIKCCSBogoEQgkkAOYRwCRgg+O0fex2zz2RmzpyTs8+cc9bn9TzzZGbvNWt/95o585m99sxEEYGZmeXrNe0uwMzM2stBYGaWOQeBmVnmHARmZplzEJiZZc5BYGaWOQfBECLpXElXtbuOVkiaIWlN6fZSSTPaVMvXJH0mXT9U0vJ+7Pu7kk5K10+WdHs/9v0BSTf3V3+92O7bJT0kaYOkP614Wy0/Hj2Nr6TbJH2o/6rLx8h2F2CbSdpQurkd8BLwarp9xsBX1H8i4k390Y+kc4E/iIgP9rGOHwN/2F/biYiZfamjzvY6gEeAbSJiU+r7G8A3+qP/XpoLXBwR86reUKuPh1XLRwSDSES8tusC/Bp4X2lZO14QAJDkNww1VBiufz97AEur3oifV4PHcH0iD2ejJF0h6fk03TKta4WkCZK+KalT0iOSPtqoE0m7SvpvSc9JWizpM+XDbkkh6W8kPQQ8lJbNk7Q63eduSYeW2m+bpmDWS1oGHFSzvVWSDk/XXyNpjqSHJa2TNF/SLmldR9r2SZJ+LekpSWendUcC/wQcn6Yt7muwbwdIuieN0XXAmNK62imrf5S0NrVdLumwRttJUw/nSboDeBHYq850hCRdLOlZSb+SdFi9MUi3y1N9P0r/PpO2+dbaqRBJb0uP1bPp37eV1t0m6V8l3ZH25WZJ4+qNT2r/YUkrJD0taYGkCWn5w8BewH+nOkbX3O8fJd1Qs2yepIvS9VMkPZBqWCnpjFK7GZLWpD6eAL5a5/Hoel48L2mZpD/bsvT641tnH09NtayXtEjSHl0dSPqCpCfTc/kXkvZr1E8WIsKXQXgBVgGH1yw7F9gIHAWMAD4L3JnWvQa4GzgHGEXxx7wSOKJB/9emy3bAVGA1cHtpfQDfB3YBtk3LPgjsSjGl+AngCWBMWnc+8OPUfjLwS2BNvf0BPgbcCUwCRgNfAq5J6zrSti8HtgXeTDFFtm9pDK5qMm6jgEeBvwO2AY4DXgE+k9bP6KqLYkpiNTChtO03NtoOcBvFkdqb0hhsk5Z9KK0/GdhU2vbxwLPALvUe0/I2Svs9srT+5K7HJI3reuCv07ZPSLd3LdX2MLB3GrfbgPMbjNG7gKeAA9P4fxH4UbPnXmndHhQhuEO6PQJ4HDgk3T4aeCMg4J2p7YGlsd8EXJC2u2358Uht/hKYQPF8Ph54Adi9xfEtPxbHAiuAfdN4/TPwk7TuCIq/lZ1Snft2bSPXi48Ihp7bI2JhRLwKXEnxQgnFO/DxETE3Il6OiJUUL6azajuQNAL4C+BTEfFiRCwDvl5nW5+NiKcj4rcAEXFVRKyLiE0RcSHFH3PX/O77gfNS+9XARU324Uzg7IhYExEvUbwgHqfuUwWfjojfRsR9wH2l/ezJIRQvEv8vIl6JiBuAxQ3avpr2YaqkbSJiVUQ83EP/X4uIpWkMXqmz/snStq8DllO8OG6to4GHIuLKtO1rgF8B7yu1+WpEPJger/nAWxr09QHgPyPinjT+ZwFvVXGeoqmIeBS4B+h6p/4u4MWIuDOt/05EPByF/wFuBg4tdfE7iufdS13Pq5r+r4+IxyLid2n8HgKml5q0Or5nUjx/H4jinMu/AW9JRwWvADsA+wBKbR7vad+HMwfB0PNE6fqLwJj0AroHMEHSM10XiumN19XpYzzFu6TVpWWr67TrtkzSJ9Oh9rOp/x2BrumHCTXtH22yD3sAN5bqfIDiRblca+1+vrZJf2UTgLWR3vo1qyUiVgB/SxFET0q6tmuKpIl641RWb9s99dmKCWy5H48CE0u3Wx2zbn1FxAZgXU1fzVxNcUQC8FfpNgCSZkq6M005PUNx9FqeouqMiI2NOpZ0oqSfl54b+9Xcv9Xx3QOYV+rnaYp3/xMj4ofAxcAlFI/7ZZLGtrLjw5WDYPhYDTwSETuVLjtExFF12nZSHGJPKi2bXKfd7//gVJwP+AeKd/47R8ROFIflSk0er+njDT3UOrOm1jERsbaHfexWUwOPAxMlqbSsYS0RcXVEvIPihSMopi2abaen7dfb9mPp+gsUU3FdXt+Lfh9LNZa9AWhlzJr2JWl7iim/Vvu6HpghaRLFkcHVqZ/RwDeBfwdel54jC9n8HIEm+5nerV8OzKaY8tqJYoqxfP9m41u2Gjij5jm2bUT8BCAiLoqIP6aYFt0b+PsW931YchAMHz8Dnk8n4raVNELSfpIOqm2YppW+BZwraTtJ+wAn9tD/DhTh0QmMlHQOUH4XNR84S9LO6QXiI036uhQ4r3TybrykY1vcz98AHWr8iZ2fpjo/KmkbSX9O96mF35P0h5LelV7ANgK/pZi6aGU7jexW2vZfUsw/L0zrfg7MSuumUZy/6NKZtr1Xg34XAntL+itJIyUdT/EidlMv6wO4BjhF0lvSvv8bcFdErGrlzhHRSTEf/1WKNx8PpFWjKKbaOoFNkmYC7+lFXdtTBEUnFCeeKY4IypqNb9mlFM/HN6W+dkztkXSQpIMlbUMRzhvZ/LhnyUEwTKQX9/dSzAs/QnEy8MsU0zf1zE7rnqA413ANxUnZRhYB3wMepDgc30j3aZJPp+WPUMwLX9mkr3nAAuBmSc9TnDg+uEn7suvTv+sk3VO7MiJeBv6c4sTi0xQnFL/VoK/RFCe5n6IYh90o5st73E4TdwFTUp/nAcdFxLq07l8oTqSupxiv30+pRMSLqf0daTrjkJr9Wkfx+H6CYhrnH4D3RsRTvaitq68fpFq+SXEE9UbqnEvqwdXA4TX78DzwUYo3Besppo0W9KKuZcCFFGH+G+CPgDtqmjUb33JfN1Ic3V0r6TmKI4uu73yMpTjyWE/xnF0HfL7VOocjdZ9us1xJugB4fUSc1O5azGxg+YggU5L2kbR/+kz1dOA04MZ212VmA8/f7MvXDhTTQRMoDsMvBL7d1orMrC08NWRmljlPDZmZZW7ITQ2NGzcuOjo62l2GmdmQcvfddz8VEePrrRtyQdDR0cGSJUvaXYaZ2ZAiqeG3/T01ZGaWOQeBmVnmHARmZplzEJiZZc5BYGaWOQeBmVnmHARmZplzEJiZZc5BYGaWuSH3zWIzs4HWMec77S4BgFXnH11Jvz4iMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMldpEEg6UtJySSskzamz/g2SbpV0r6T7JR1VZT1mZralyoJA0gjgEmAmMBU4QdLUmmb/DMyPiAOAWcD/r6oeMzOrr8ojgunAiohYGREvA9cCx9a0CWBsur4j8FiF9ZiZWR1VBsFEYHXp9pq0rOxc4IOS1gALgY/U60jS6ZKWSFrS2dlZRa1mZtlq98niE4CvRcQk4CjgSklb1BQRl0XEtIiYNn78+AEv0sxsOKsyCNYCk0u3J6VlZacB8wEi4qfAGGBchTWZmVmNKoNgMTBF0p6SRlGcDF5Q0+bXwGEAkvalCALP/ZiZDaDKgiAiNgGzgUXAAxSfDloqaa6kY1KzTwAflnQfcA1wckREVTWZmdmWRlbZeUQspDgJXF52Tun6MuDtVdZgZmbNtftksZmZtZmDwMwscw4CM7PMOQjMzDLnIDAzy5yDwMwscw4CM7PMOQjMzDLnIDAzy5yDwMwscw4CM7PMOQjMzDLnIDAzy5yDwMwscw4CM7PMOQjMzDLnIDAzy5yDwMwscw4CM7PMOQjMzDLnIDAzy5yDwMwscw4CM7PMOQjMzDLnIDAzy5yDwMwscw4CM7PMOQjMzDLnIDAzy5yDwMwscw4CM7PMOQjMzDLnIDAzy5yDwMwscw4CM7PMOQjMzDLnIDAzy5yDwMwsc5UGgaQjJS2XtELSnAZt3i9pmaSlkq6ush4zM9vSyKo6ljQCuAR4N7AGWCxpQUQsK7WZApwFvD0i1kvarap6zMysviqPCKYDKyJiZUS8DFwLHFvT5sPAJRGxHiAinqywHjMzq6PKIJgIrC7dXpOWle0N7C3pDkl3SjqyXkeSTpe0RNKSzs7Oiso1M8tTu08WjwSmADOAE4DLJe1U2ygiLouIaRExbfz48QNboZnZMFdlEKwFJpduT0rLytYACyLilYh4BHiQIhjMzGyAVBkEi4EpkvaUNAqYBSyoafNfFEcDSBpHMVW0ssKazMysRmVBEBGbgNnAIuABYH5ELJU0V9IxqdkiYJ2kZcCtwN9HxLqqajIzsy1V9vFRgIhYCCysWXZO6XoAH08XMzNrg3afLDYzszZzEJiZZc5BYGaWOQeBmVnmHARmZplzEJiZZc5BYGaWOQeBmVnmHARmZplzEJiZZc5BYGaWOQeBmVnmHARmZplzEJiZZc5BYGaWOQeBmVnmWv6PaSS9GTg03fxxRNxXTUlmZjaQWjoikPQx4BvAbulylaSPVFmYmZkNjFaPCE4DDo6IFwAkXQD8FPhiVYWZmdnAaPUcgYBXS7dfTcvMzGyIa/WI4KvAXZJuTLf/FPhKJRWZmdmAaikIIuI/JN0GvCMtOiUi7q2sKjMzGzBNg0DS2Ih4TtIuwKp06Vq3S0Q8XW15ZmZWtZ6OCK4G3gvcDURpudLtvSqqy8zMBkjTIIiI96Z/9xyYcszMbKC1+j2CW1pZZmZmQ09P5wjGANsB4yTtzOaPjI4FJlZcm5mZDYCezhGcAfwtMIHiPEFXEDwHXFxdWWZmNlB6OkcwD5gn6SMR4W8Rm5kNQ61+j+CLkvYDpgJjSsuvqKowMzMbGC0FgaRPATMogmAhMBO4HXAQmJkNca3+1tBxwGHAExFxCvBmYMfKqjIzswHTahBsjIjfAZskjQWeBCZXV5aZmQ2UHqeGJAm4X9JOwOUUnx7aQPEz1GZmNsT1GAQREZKmR8QzwKWSvgeMjYj7K6/OzMwq1+rU0D2SDgKIiFUOATOz4aPV/4/gYOADkh4FXiD96FxE7F9ZZWZmNiBaDYIj+tK5pCOBecAI4MsRcX6Ddn8B3AAcFBFL+rItMzPrm1a/UPZobzuWNAK4BHg3sAZYLGlBRCyrabcD8DHgrt5uw8zMtl6r5wj6YjqwIiJWRsTLwLXAsXXa/StwAbCxwlrMzKyBKoNgIrC6dHsNNb9YKulAYHJEfKdZR5JOl7RE0pLOzs7+r9TMLGNVBkFTkl4D/AfwiZ7aRsRlETEtIqaNHz+++uLMzDJSZRCspfu3jyelZV12APYDbpO0CjgEWCBpWoU1mZlZjSqDYDEwRdKekkYBs4AFXSsj4tmIGBcRHRHRAdwJHONPDZmZDazKgiAiNgGzgUXAA8D8iFgqaa6kY6rarpmZ9U6r3yPok4hYSPGz1eVl5zRoO6PKWszMrL62nSw2M7PBwUFgZpY5B4GZWeYcBGZmmXMQmJllzkFgZpY5B4GZWeYcBGZmmXMQmJllzkFgZpY5B4GZWeYcBGZmmXMQmJllzkFgZpY5B4GZWeYcBGZmmXMQmJllzkFgZpY5B4GZWeYcBGZmmXMQmJllzkFgZpY5B4GZWeYcBGZmmXMQmJllzkFgZpY5B4GZWeYcBGZmmXMQmJllzkFgZpY5B4GZWeYcBGZmmXMQmJllzkFgZpY5B4GZWeYcBGZmmXMQmJllzkFgZpa5SoNA0pGSlktaIWlOnfUfl7RM0v2SbpG0R5X1mJnZlioLAkkjgEuAmcBU4ARJU2ua3QtMi4j9gRuAz1VVj5mZ1VflEcF0YEVErIyIl4FrgWPLDSLi1oh4Md28E5hUYT1mZlZHlUEwEVhdur0mLWvkNOC79VZIOl3SEklLOjs7+7FEMzMbFCeLJX0QmAZ8vt76iLgsIqZFxLTx48cPbHFmZsPcyAr7XgtMLt2elJZ1I+lw4GzgnRHxUoX1mJlZHVUeESwGpkjaU9IoYBawoNxA0gHAl4BjIuLJCmsxM7MGKguCiNgEzAYWAQ8A8yNiqaS5ko5JzT4PvBa4XtLPJS1o0J2ZmVWkyqkhImIhsLBm2Tml64dXuX0zM+vZoDhZbGZm7eMgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLXKU/Q21mQ1PHnO+0uwQAVp1/dLtLyIKPCMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzlQaBpCMlLZe0QtKcOutHS7ourb9LUkeV9ZiZ2ZYqCwJJI4BLgJnAVOAESVNrmp0GrI+IPwC+AFxQVT1mZlZflUcE04EVEbEyIl4GrgWOrWlzLPD1dP0G4DBJqrAmMzOrMbLCvicCq0u31wAHN2oTEZskPQvsCjxVbiTpdOD0dHODpOWVVNyacdTUlzmPx2Yei+62ejw0vOYI2j0eezRaUWUQ9JuIuAy4rN11AEhaEhHT2l3HYOHx2Mxj0Z3Ho7vBPB5VTg2tBSaXbk9Ky+q2kTQS2BFYV2FNZmZWo8ogWAxMkbSnpFHALGBBTZsFwEnp+nHADyMiKqzJzMxqVDY1lOb8ZwOLgBHAf0bEUklzgSURsQD4CnClpBXA0xRhMdgNiimqQcTjsZnHojuPR3eDdjzkN+BmZnnzN4vNzDLnIDAzy1z2QZBOZt+VfubiunRiu167s1Kb5ZKOKC2v+zMajfqV9CeS7pG0SdJxfaxZkn4oaWyzGmru0/DnPPqwb7PTspA0rkmddfutadNonOrWK2lXSbdK2iDp4pq+fiBp59LtbSX9j6QRkk6S9FC6nEQdknaR9P3U5vtdfaXxvijVcr+kA0v3+Z6kZyTd1GQc6vZbp13dGiWdJ2m1pA017WdLOrXRdlvVj+O0j6SfSnpJ0iebbO+PJf0ijedF0pZfIm3Ul6RRkn6k4lOGg16j53dNm4bP6QETEdldgFHA9un6fGBWun4p8H/qtJ8K3AeMBvYEHqY4AT4iXd8r9XkfMLVZv0AHsD9wBXBcH+s/GvhCut6whpr7/F/g0nR9FnDdVuzbAWk/VgHjGtRYt9867RqNU6N6twfeAZwJXFzT10nA2aXbfwN8DNgFWJn+3Tld37lOLZ8D5qTrc4AL0vWjgO8CAg4B7ird5zDgfcBNTR6vuv3WtGlYY9rm7sCGmvtsB9zbD38P/TVOuwEHAecBn2yyvZ+lfVIa15l12jTsC/gU8IH+fl3o49htMT6tPL9r2jR8Tg/YfrR7IAf4QdsXuBB4hOLFTBTf9BuZ1r8VWFTnfmcBZ5VuL0ptu7XvatdKv8DX6HsQXA3MqNd3ba21NafrI1N96u2+1fS5isZBULffmjYNx6lRvaX7nlz7R5NevH5Zuv0TisA6AfhSafmXgBPq1Lwc2D1d3x1YXq99uV26PYPmQVC335o2PdZITRCkZTcC07fy76Jfxqm0/lwaBEFq/6tG+12n/RZ9AW8GFm7NPvfXheINzjeAd5Wfnz09vxv0tcVzeqAuw35qSNL2kk6RdDtwObAM2D8i7qX4OYtnImJTar6G4mcvatX7uYyJTZa32m9fvR24u4faanX7OQ+g6+c8ertvrWrl/s3GqVG9DUXEemB0OtQeBewVEat6sS+vi4jH0/UngNf1Yl+aadRvWV+3sQQ4tBe1dNPP49SKianfnrbRzC8pjhYGg72Ba4DZwDJJ/yRpQlpX9etAvxkS82xb6XHgfuBDEfGrdhfTT3aJiOfbXcQg9SQwgeIb6s/0tZOICEn9/tnqCvp9EthnK+4/jkE4Tj1s81VJL0vaod1/BxHxKnATcJOk8cBngV9LehvF1NqQMOyPCCi+sbwW+JakcySVf3hpHbBT6cRTvZ/BgMY/l9Foeav99tUmSV2PXSs/5dGtnbr/nEdv961Vrdy/2Tj19edHxgC/TZcxvagF4DeSdk/b3J3iRbY392+kUb9lfd1G1/72VX+OUyvWpn572kZPRgMb+3C/fidpR0lnUPxSwhTgVIo3n1W/DvSbYR8EEXFzRBxPcfj8LPDt9OmSjigm5m6lCAsoTjZ+u043C4BZ6ZMse1I82D+jwc9o9KLfvlpOcRKXRjU02Id6P+fRq31rVpSk6ZKuKG2vXr+/18M49frnR9KnT14PrErTRCMkjaE43/AeSTunT7i8Jy2rVd5mbS0npk8PHQI8W5oaaVTLZyX9WQ/9lrVaY629KaZK+qSfx6khSbdImpjG7TlJh6TH68RW7l/T167AUxHxSm/uVwVJVwH3UHwg4sSIeGdEXBERGwfgdaD/tPtkSzsuFP9XwuR0fS+KF6gVwPXA6LT8GGBu6T5nU5wYWk7pUw4Unyh5MK0rf2KlUb8HUcwVvkDxjmFpH+r/F4qprp5qmAsck66PSXWsSHXttRX79tG0D5uAx4Avp+XH0f1kY6N+FwITehinZvWuovhJkg2pjq5PM00Dvllq9xXg8HT91NTXCuCUUpsvA9PS9V2BW4CHgB9QTMFBcdLvkrQvv+hqn9b9GOikeGe9BjgiLb+JzSe7G/U7rWvseqjxc6nv36V/zy2tuwfYdSv/HvprnF6f6nuOYrppDTCW4g3no8C2pf3+ZRrPi9n8CwdnAmc266v0PLuw3a8jpdeJkU3Wt/r6Uvc5PVAX/8TEEJQOx6+IiHe3u5YySZ8HroyI+9u0/XkUR2S3pNsHAn8XEX/dhloWRUTd70704zYOAD6+tftX9ThJ2g84NSI+3k/9fYvi46sP9kd/5t8aGrIkvR/4XkQ81+5aBgtJH46Iy2uWnQp8PYqTesOKpHcDD0XxiZ+t7WtIjFPXNGVEXNFjY2uZg8DMLHPD/mSxmZk15yAwM8ucg8DMLHMOAjOzzDkIzMwy97/zxVkF1+RVfgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 超参数设置\n",
    "selected_qubit = [2, 4, 6, 8]\n",
    "means, variances = [], []\n",
    "\n",
    "# 不断增加量子比特数量\n",
    "for N in selected_qubit:\n",
    "    grad_info = []\n",
    "    THETA_SIZE = N                \n",
    "    target = np.random.choice(3, N)\n",
    "    # 在 0 - 2*Pi 间随机生成各参数值\n",
    "    cir = rand_circuit(target, N)\n",
    "    \n",
    "    H_l = Hamiltonian(random_pauli_str_generator(N, terms=10))\n",
    "    \n",
    "    grad_mean_list, grad_variance_list = random_sample(cir, loss_func, samples, H_l, mode='max')\n",
    "    # 记录采样信息\n",
    "    means.append(grad_mean_list)\n",
    "    variances.append(grad_variance_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接着对采样不同量子比特数量电路得到的各参数最大梯度的平均值和方差作图，方便比较。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我们接着画出这个采样出来的梯度的统计结果：\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 960x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "means = np.array(means)\n",
    "variances = np.array(variances)\n",
    "\n",
    "n = np.array(selected_qubit)\n",
    "print(\"我们接着画出这个采样出来的梯度的统计结果：\")\n",
    "fig = plt.figure(figsize=plt.figaspect(0.3))\n",
    "\n",
    "# ============= 第一张图 =============\n",
    "# 统计出随机采样的梯度平均值和量子比特数量的关系\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(n, means, \"o-.\")\n",
    "plt.xlabel(r\"Qubit #\")\n",
    "plt.ylabel(r\"$ \\partial \\theta_{i} \\langle 0|H |0\\rangle$ Mean\")\n",
    "plt.title(\"Mean of {} sampled gradient\".format(samples))\n",
    "plt.xlim([1,9])\n",
    "plt.grid()\n",
    "\n",
    "# ============= 第二张图 =============\n",
    "# 统计出随机采样的梯度的方差和量子比特数量的关系\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(n, np.log(variances), \"v-\")\n",
    "plt.xlabel(r\"Qubit #\")\n",
    "plt.ylabel(r\"$ \\partial \\theta_{i} \\langle 0|H |0\\rangle$ Variance\")\n",
    "plt.title(\"Variance of {} sampled gradient\".format(samples))\n",
    "plt.xlim([1,9])\n",
    "plt.grid()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看出，随着量子比特数量的增加，多次采样获得所有参数梯度的最大值不断接近于 0，且方差也是呈下降趋势。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了进一步看看梯度随量子比特数量增加发生的变化，我们不妨可视化一下不同量子比特数量对的优化曲面的影响：\n",
    "\n",
    "![BP-fig-qubit_landscape_compare](./figures/BP-fig-qubit_landscape_compare.png \"(a)不固定 z 轴尺度时，采样出的优化曲面分别从左至右对应2、4和6量子比特的情形。（b）同样的优化曲面但是固定 z 轴尺度作为对比。\")\n",
    "         \n",
    "\n",
    "画图时 $\\theta_1$ 和 $\\theta_2$ 是前两个电路参数, 剩余参数全部固定为 $\\pi$。不然我们画不出这个高维度的流形。\n",
    "结果不出所料，陡峭程度随着 $n$ 的增大越来越小了，**注意到 Z 轴尺度的极速减小**。相对于 2 量子比特的情况，6 量子比特的优化曲面已经非常扁平了。\n",
    "\n",
    "在理论上，只有当我们选取的网络结构还有损失函数满足一定条件时 (2-design)[[1]](https://arxiv.org/abs/1803.11173), 才会出现这种梯度随量子比特数增加而急剧消失的现象。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 应用 二：基于经典数据量子编码的监督学习\n",
    "\n",
    "监督学习是量子神经网络的重要应用之一，然而贫瘠高原现象同样制约着量子变分算法在此类问题上的表现。因此，如何设计更有效的电路和损失函数来避免贫瘠高原现象的出现，是当前量子神经网络的重要研究方向之一。实际上，已有学者证明，在生成模型 (generative model) 的训练之中使用瑞丽熵 (Renyi divergence) 作为损失函数，可以有效避免贫瘠高原现象 [[3]](https://arxiv.org/abs/2106.09567)。 基于量桨的梯度分析模块，我们可以快速分析一个监督学习模型中梯度的相关信息，从而便于研究者尝试探索不同的量子电路和损失函数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里，我们利用量桨的[量子态编码经典数据](./tutorial/machine_learning/DataEncoding_CN.ipynb)提供的数据集为例进行介绍。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Paddle Quantum 实现\n",
    "\n",
    "首先，导入需要的包"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from paddle_quantum.dataset import Iris\n",
    "from paddle_quantum.gradtool import random_sample_supervised, plot_supervised_loss_grad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 定义参数化量子电路\n",
    "\n",
    "接着，构建参数化量子电路 $U(\\theta)$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def U_theta(n: int, depth: int):\n",
    "    # 初始化网络\n",
    "    cir = Circuit(n)\n",
    "\n",
    "    # 先搭建广义的旋转层\n",
    "    cir.rz()\n",
    "    cir.ry()\n",
    "    cir.rz()\n",
    "\n",
    "    # 默认深度为 depth = 1\n",
    "    # 搭建纠缠层和 Ry旋转层\n",
    "    for _ in range(3, depth + 3):\n",
    "        cir.cnot()\n",
    "        cir.ry()\n",
    "        \n",
    "    return cir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 定义目标函数\n",
    "\n",
    "这里定义要优化的目标函数，第二个参数仍然是可变参数 ``*args``。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss_func(cir: Circuit, *args):\n",
    "    #传入量子态和训练标签\n",
    "    state_in = args[0]\n",
    "    label = args[1]\n",
    "    # 将 Numpy array 转换成 tensor\n",
    "    label_pp = paddle.to_tensor(label).reshape([-1, 1])\n",
    "    \n",
    "    Utheta = cir.unitary_matrix()\n",
    "    \n",
    "    # 因为 Utheta是学习到的，我们这里用行向量运算来提速而不会影响训练效果\n",
    "    state_out = state_in @ Utheta\n",
    "    \n",
    "    # 测量得到泡利 Z 算符的期望值 <Z>\n",
    "    Ob = paddle.to_tensor(pauli_str_to_matrix([[1.0, 'z0']], qubit_num))\n",
    "    E_Z = state_out @ Ob @ paddle.transpose(paddle.conj(state_out), perm=[0, 2, 1])\n",
    "\n",
    "    # 映射 <Z> 处理成标签的估计值\n",
    "    state_predict = paddle.real(E_Z)[:, 0] * 0.5 + 0.5\n",
    "    loss = paddle.mean((state_predict - label_pp) ** 2)  #均方误差\n",
    "    \n",
    "    return loss\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 定义数据集\n",
    "\n",
    "接着导入量子编码后的 Iris 数据集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Rz(0.812)----Ry(1.897)----Rz(4.609)----*----x----Ry(1.629)--\n",
      "                                         |    |               \n",
      "--Rz(0.351)----Ry(2.939)----Rz(5.847)----x----*----Ry(0.576)--\n",
      "                                                              \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\fluid\\framework.py:1104: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  elif dtype == np.bool:\n"
     ]
    }
   ],
   "source": [
    "time_start = time.time()\n",
    "\n",
    "#超参数设置,这里不需要太多qubit，不然严重过拟合\n",
    "test_rate = 0.2\n",
    "qubit_num = 2\n",
    "depth = 1\n",
    "lr = 0.1\n",
    "BATCH = 4\n",
    "EPOCH = 4\n",
    "SAMPLE = 300\n",
    "# 验证数据集\n",
    "iris = Iris(encoding='amplitude_encoding', num_qubits=qubit_num, test_rate=test_rate, classes=[0,1], return_state=True)\n",
    "\n",
    "# 获取数据集的输入和标签\n",
    "train_x, train_y = iris.train_x, iris.train_y  #这里的 train_x, train_y，test_x, test_y 都是 paddle.tensor\n",
    "test_x, test_y = iris.test_x, iris.test_y\n",
    "testing_data_num = len(test_y)\n",
    "training_data_num = len(train_y)\n",
    "\n",
    "\n",
    "# 为量子电路创建可训练的参数\n",
    "# 创建电路\n",
    "circuit = U_theta(qubit_num, depth)\n",
    "\n",
    "print(circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们先看看在 EPOCH=4，BATCH=4 的情况下，训练过程中的损失函数值及梯度的变化情况"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\tensor\\creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  if data.dtype == np.object:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "loss,grad = plot_supervised_loss_grad(circuit, loss_func, N=qubit_num, EPOCH=EPOCH, LR=lr,BATCH=BATCH, TRAIN_X=train_x, TRAIN_Y=train_y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以看到在几十个 iteration 之后，损失函数的值只在一个较小的范围内波动，说明训练过程已经达到了稳定。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接着我们再对该模型的初始参数进行随机采样 300 次，这里我们首先选择 ``max`` 模式，看看 300 次采样中每次采样中最大梯度的平均值和方差"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Sampling: 100%|###################################################| 300/300 [00:03<00:00, 76.54it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean of max gradient\n",
      "0.15144292\n",
      "Variance of max gradient\n",
      "0.0035474023\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEICAYAAABS0fM3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAdxElEQVR4nO3deZxcZZ3v8c/XQACRPa2QjQQnDEREwSbiwsiLRYNo4oyoiTqsGrjXCNdlxjA4kcnIKHrVC5L7wriDQkCUa4utcYNREDBh1SQGmhBIR5AmhF2WwO/+cZ6G05VT1dWdPl1Jn+/79apXn+Wp5/zOU6fPr87zVJ1SRGBmZtX1klYHYGZmreVEYGZWcU4EZmYV50RgZlZxTgRmZhXnRGBmVnFOBFsRSWdL+l6r42iGpMMldefml0s6vEWxfEfSZ9P0YZJWDWHdP5N0Qpo+UdK1Q1j3ByT9YqjqG8B23yTpTkmPS3pXydtq+vXor30lXSPpQ0MXXXVs0+oA7EWSHs/NvhR4GnguzZ86/BENnYh41VDUI+ls4O8i4oODjON3wN8P1XYi4pjBxFGwvUnA3cC2EbEx1f194PtDUf8ALQAuiIjzyt5Qs6+HlctXBFuQiHhZ7wO4F3hnblkrTggASPIbhhrKjNT/n72B5WVvxMfVlmOkHsgj2WhJF0l6LHW3tPeukDRW0g8l9Ui6W9Lp9SqRtIekn0h6VNJSSZ/NX3ZLCkkfkXQncGdadp6ktek5N0k6LFd+h9QFs0HSCuCQmu2tkXRUmn6JpHmS7pK0XtLlknZP6yalbZ8g6V5JD0o6K62bDvwb8L7UbXFbnX07SNLNqY0uA7bPravtsvqUpHWp7CpJR9bbTup6OEfSdcCTwD4F3RGSdIGkRyT9WdKRRW2Q5vNdfb9Nfx9O23xDbVeIpDem1+qR9PeNuXXXSPpPSdelffmFpDFF7ZPKf1hSl6SHJHVIGpuW3wXsA/wkxbFdzfM+JemKmmXnSTo/TZ8kaWWKYbWkU3PlDpfUneq4H/h2wevRe1w8JmmFpH/cNPTi9i3Yx5NTLBskLZG0d28Fkr4i6YF0LP9R0gH16qmEiPBjC3wAa4CjapadDTwFvB0YBXwOuCGtewlwEzAfGE32z7waeFud+henx0uBqcBa4Nrc+gB+CewO7JCWfRDYg6xL8RPA/cD2ad3ngd+l8hOAPwHdRfsDnAHcAIwHtgO+Blya1k1K2/46sAPwGrIusv1zbfC9Bu02GrgH+BiwLXAc8Czw2bT+8N64yLok1gJjc9t+Zb3tANeQXam9KrXBtmnZh9L6E4GNuW2/D3gE2L3oNc1vI7ff2+TWn9j7mqR23QD8c9r27DS/Ry62u4B9U7tdA3y+ThsdATwIHJza/6vAbxsde7l1e5MlwZ3S/CjgPuDQNH8s8EpAwFtS2YNzbb8RODdtd4f865HKvAcYS3Y8vw94AtiryfbNvxYzgS5g/9RenwZ+n9a9jex/ZdcU5/6926jqw1cEW59rI6IzIp4DLiY7UUL2DrwtIhZExDMRsZrsZDqrtgJJo4B3A5+JiCcjYgXw3YJtfS4iHoqIvwFExPciYn1EbIyIL5H9M/f2774XOCeVXwuc32AfTgPOiojuiHia7IR4nPp2FfxHRPwtIm4DbsvtZ38OJTtJ/J+IeDYirgCW1in7XNqHqZK2jYg1EXFXP/V/JyKWpzZ4tmD9A7ltXwasIjs5bq5jgTsj4uK07UuBPwPvzJX5dkTckV6vy4HX1qnrA8C3IuLm1P5nAm9QNk7RUETcA9wM9L5TPwJ4MiJuSOt/GhF3Rea/gV8Ah+WqeJ7suHu697iqqf8HEfGXiHg+td+dwLRckWbb9zSy43dlZGMu/wW8Nl0VPAvsBOwHKJW5r799H8mcCLY+9+emnwS2TyfQvYGxkh7ufZB1b7yioI42sndJa3PL1haU67NM0ifTpfYjqf5dgN7uh7E15e9psA97A1fm4lxJdlLOx1q7ny9rUF/eWGBdpLd+jWKJiC7gf5ElogckLe7tImmgqJ3yirbdX53NGMum+3EPMC4332yb9akrIh4H1tfU1cglZFckAO9P8wBIOkbSDanL6WGyq9d8F1VPRDxVr2JJx0u6NXdsHFDz/Gbbd2/gvFw9D5G9+x8XEb8BLgAWkr3uiyTt3MyOj1ROBCPHWuDuiNg199gpIt5eULaH7BJ7fG7ZhIJyL/zDKRsP+Feyd/67RcSuZJflSkXuq6ljYj+xHlMT6/YRsa6ffewTUx33AeMkKbesbiwRcUlEvJnsxBFk3RaNttPf9ou2/Zc0/QRZV1yvPQdQ719SjHkTgWbarGFdknYk6/Jrtq4fAIdLGk92ZXBJqmc74IfA/wZekY6RTl48RqDBfqZ3618H5pJ1ee1K1sWYf36j9s1bC5xac4ztEBG/B4iI8yPidWTdovsC/9Lkvo9ITgQjxx+Ax9JA3A6SRkk6QNIhtQVTt9KPgLMlvVTSfsDx/dS/E1ny6AG2kTQfyL+Luhw4U9Ju6QTx0QZ1XQickxu8a5M0s8n9/CswSfU/sXN9ivN0SdtK+if6di28QNLfSzoincCeAv5G1nXRzHbqeXlu2+8h63/uTOtuBWalde1k4xe9etK296lTbyewr6T3S9pG0vvITmJXDTA+gEuBkyS9Nu37fwE3RsSaZp4cET1k/fHfJnvzsTKtGk3W1dYDbJR0DPDWAcS1I1mi6IFs4JnsiiCvUfvmXUh2PL4q1bVLKo+kQyS9XtK2ZMn5KV583SvJiWCESCf3d5D1C99NNhj4DbLumyJz07r7ycYaLiUblK1nCfBz4A6yy/Gn6NtN8h9p+d1k/cIXN6jrPKAD+IWkx8gGjl/foHzeD9Lf9ZJurl0ZEc8A/0Q2sPgQ2YDij+rUtR3ZIPeDZO3wcrL+8n6308CNwJRU5znAcRGxPq37d7KB1A1k7fVCl0pEPJnKX5e6Mw6t2a/1ZK/vJ8i6cf4VeEdEPDiA2Hrr+lWK5YdkV1CvpGAsqR+XAEfV7MNjwOlkbwo2kHUbdQwgrhXAl8iS+V+BVwPX1RRr1L75uq4ku7pbLOlRsiuL3u987Ex25bGB7JhdD3yx2ThHIvXtbrOqknQusGdEnNDqWMxsePmKoKIk7SfpwPSZ6mnAKcCVrY7LzIafv9lXXTuRdQeNJbsM/xLw45ZGZGYt4a4hM7OKc9eQmVnFbXVdQ2PGjIlJkya1Ogwzs63KTTfd9GBEtBWt2+oSwaRJk1i2bFmrwzAz26pIqvtt/1K7hiRNV3ZHxy5J8wrWT5R0taRbJN0uqehbsGZmVqLSEkG6sdlCsi9xTAVmS5paU+zTwOURcRDZF1r+b1nxmJlZsTKvCKYBXRGxOn3bczHZrWHzghdvU7ALxfcMMTOzEpWZCMbR9xYE3Wx6d8OzgQ8q+2GKTurcn0bSHEnLJC3r6ekpI1Yzs8pq9cdHZ5Pd33082e1qLy66yVdELIqI9ohob2srHPQ2M7NBKjMRrKPvbYnHs+ltbk8hu0EVEXE92U8K1v15PTMzG3plJoKlwBRJkyWNJhsMrr0T4b3AkQCS9idLBO77MTMbRqUlgvTzcHPJbl+8kuzTQcslLZA0IxX7BPBhZT8OfilwYvieF2Zmw6rUL5RFRCc1PxoREfNz0yuAN5UZg5mZNbbVfbPYzGy4TZr301aHAMCazx9bSr2t/tSQmZm1mBOBmVnFORGYmVWcE4GZWcU5EZiZVZwTgZlZxTkRmJlVnBOBmVnFORGYmVWcE4GZWcU5EZiZVZwTgZlZxTkRmJlVnBOBmVnFORGYmVWcE4GZWcU5EZiZVVypiUDSdEmrJHVJmlew/iuSbk2POyQ9XGY8Zma2qdJ+qlLSKGAhcDTQDSyV1JF+pxiAiPhYrvxHgYPKisfMzIqVeUUwDeiKiNUR8QywGJjZoPxs4NIS4zEzswJlJoJxwNrcfHdatglJewOTgd/UWT9H0jJJy3p6eoY8UDOzKttSBotnAVdExHNFKyNiUUS0R0R7W1vbMIdmZjaylZkI1gETcvPj07Iis3C3kJlZS5SZCJYCUyRNljSa7GTfUVtI0n7AbsD1JcZiZmZ1lJYIImIjMBdYAqwELo+I5ZIWSJqRKzoLWBwRUVYsZmZWX2kfHwWIiE6gs2bZ/Jr5s8uMwczMGttSBovNzKxFnAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4kpNBJKmS1olqUvSvDpl3itphaTlki4pMx4zM9tUaT9VKWkUsBA4GugGlkrqiIgVuTJTgDOBN0XEBkkvLyseMzMrVuYVwTSgKyJWR8QzwGJgZk2ZDwMLI2IDQEQ8UGI8ZmZWoMxEMA5Ym5vvTsvy9gX2lXSdpBskTS8xHjMzK1Ba19AAtj8FOBwYD/xW0qsj4uF8IUlzgDkAEydOHOYQzcxGtjKvCNYBE3Lz49OyvG6gIyKejYi7gTvIEkMfEbEoItojor2tra20gM3MqqjMRLAUmCJpsqTRwCygo6bM/yO7GkDSGLKuotUlxmRmZjVKSwQRsRGYCywBVgKXR8RySQskzUjFlgDrJa0Argb+JSLWlxWTmZltqtQxgojoBDprls3PTQfw8fQwM7MW8DeLzcwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4kpNBJKmS1olqUvSvIL1J0rqkXRrenyozHjMzGxTpf1msaRRwELgaKAbWCqpIyJW1BS9LCLmlhWHmZk1VuYVwTSgKyJWR8QzwGJgZonbMzOzQSgzEYwD1ubmu9OyWu+WdLukKyRNKKpI0hxJyyQt6+npKSNWM7PKavVg8U+ASRFxIPBL4LtFhSJiUUS0R0R7W1vbsAZoZjbSlZkI1gH5d/jj07IXRMT6iHg6zX4DeF2J8ZiZWYEyE8FSYIqkyZJGA7OAjnwBSXvlZmcAK0uMx8zMCpT2qaGI2ChpLrAEGAV8KyKWS1oALIuIDuB0STOAjcBDwIllxWNmZsVKSwQAEdEJdNYsm5+bPhM4s8wYzMyssVYPFpuZWYs5EZiZVZwTgZlZxTkRmJlVnBOBmVnFORGYmVWcE4GZWcU5EZiZVZwTgZlZxTX9zWJJrwEOS7O/i4jbygnJzMyGU1NXBJLOAL4PvDw9vifpo2UGZmZmw6PZK4JTgNdHxBMAks4Frge+WlZgZmY2PJodIxDwXG7+ubTMzMy2cs1eEXwbuFHSlWn+XcA3S4nIzMyGVVOJICK+LOka4M1p0UkRcUtpUZmZ2bBpmAgk7RwRj0raHViTHr3rdo+Ih8oNz8zMytbfFcElwDuAm4DILVea36ekuMzMbJg0HCyOiHekv5MjYp/cY3JE9JsEJE2XtEpSl6R5Dcq9W1JIah/4LpiZ2eZo9nsEv25mWc36UcBC4BhgKjBb0tSCcjsBZwA3NhOLmZkNrYaJQNL2aXxgjKTdJO2eHpOAcf3UPQ3oiojVEfEMsBiYWVDuP4FzgacGHr6ZmW2u/q4ITiUbH9gv/e19/Bi4oJ/njgPW5ua7qUkekg4GJkTETwcQs5mZDaGGg8URcR5wnqSPRsSQfotY0kuALwMnNlF2DjAHYOLEiUMZhplZ5TX7PYKvSjqArK9/+9zyixo8bR0wITc/Pi3rtRNwAHCNJIA9gQ5JMyJiWc32FwGLANrb2/OfXjIzs83UVCKQ9BngcLJE0Ek2AHwt0CgRLAWmSJpMlgBmAe/vXRkRjwBjctu4BvhkbRIwM7NyNXuvoeOAI4H7I+Ik4DXALo2eEBEbgbnAEmAlcHlELJe0QNKMzYjZzMyGULP3GnoqIp6XtFHSzsAD9O32KRQRnWRXEPll8+uUPbzJWMzMbAj1mwiUdeDfLmlX4Otknxp6nOw21GZmtpXrNxFEREiaFhEPAxdK+jmwc0TcXnp0ZmZWumbHCG6WdAhARKxxEjAzGzmaHSN4PfABSfcAT5BuOhcRB5YWmZmZDYtmE8HbSo3CzMxaptkvlN1TdiBmZtYazY4RmJnZCOVEYGZWcU4EZmYV50RgZlZxTgRmZhXnRGBmVnFOBGZmFedEYGZWcU4EZmYV50RgZlZxTgRmZhXnRGBmVnGlJgJJ0yWtktQlaV7B+tMk/VHSrZKulTS1zHjMzGxTpSUCSaOAhcAxwFRgdsGJ/pKIeHVEvBb4AvDlsuIxM7NiZV4RTAO6ImJ1RDwDLAZm5gtExKO52R2BKDEeMzMr0OwP0wzGOGBtbr6b7JfO+pD0EeDjwGjgiKKKJM0B5gBMnDhxyAM1M6uylg8WR8TCiHgl8Cng03XKLIqI9ohob2trG94AzcxGuDITwTpgQm5+fFpWz2LgXSXGY2ZmBcpMBEuBKZImSxoNzAI68gUkTcnNHgvcWWI8ZmZWoLQxgojYKGkusAQYBXwrIpZLWgAsi4gOYK6ko4BngQ3ACWXFY2ZmxcocLCYiOoHOmmXzc9NnlLl9MzPrX8sHi83MrLWcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4kr9PQIz2zpNmvfTVocAwJrPH9vqECrBVwRmZhXnRGBmVnGlJgJJ0yWtktQlaV7B+o9LWiHpdkm/lrR3mfGYmdmmSksEkkYBC4FjgKnAbElTa4rdArRHxIHAFcAXyorHzMyKlXlFMA3oiojVEfEMsBiYmS8QEVdHxJNp9gZgfInxmJlZgTITwThgbW6+Oy2r5xTgZ0UrJM2RtEzSsp6eniEM0czMtojBYkkfBNqBLxatj4hFEdEeEe1tbW3DG5yZ2QhX5vcI1gETcvPj07I+JB0FnAW8JSKeLjEeMzMrUOYVwVJgiqTJkkYDs4COfAFJBwFfA2ZExAMlxmJmZnWUlggiYiMwF1gCrAQuj4jlkhZImpGKfRF4GfADSbdK6qhTnZmZlaTUW0xERCfQWbNsfm76qDK3b2Zm/dsiBovNzKx1nAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4kpNBJKmS1olqUvSvIL1/yDpZkkbJR1XZixmZlastEQgaRSwEDgGmArMljS1pti9wInAJWXFYWZmjZX5m8XTgK6IWA0gaTEwE1jRWyAi1qR1z5cYh5mZNVBm19A4YG1uvjstGzBJcyQtk7Ssp6dnSIIzM7PMVjFYHBGLIqI9Itrb2tpaHY6Z2YhSZiJYB0zIzY9Py8zMbAtSZiJYCkyRNFnSaGAW0FHi9szMbBBKSwQRsRGYCywBVgKXR8RySQskzQCQdIikbuA9wNckLS8rHjMzK1bmp4aIiE6gs2bZ/Nz0UrIuIzMza5GtYrDYzMzK40RgZlZxTgRmZhXnRGBmVnFOBGZmFedEYGZWcU4EZmYV50RgZlZxTgRmZhXnRGBmVnFOBGZmFedEYGZWcU4EZmYV50RgZlZxTgRmZhXnRGBmVnFOBGZmFedEYGZWcaUmAknTJa2S1CVpXsH67SRdltbfKGlSmfGYmdmmSksEkkYBC4FjgKnAbElTa4qdAmyIiL8DvgKcW1Y8ZmZWrMwrgmlAV0SsjohngMXAzJoyM4HvpukrgCMlqcSYzMysxjYl1j0OWJub7wZeX69MRGyU9AiwB/BgvpCkOcCcNPu4pFWlRNycMdTEV3Fujxe5Lfra7PbQyOojaHV77F1vRZmJYMhExCJgUavjAJC0LCLaWx3HlsLt8SK3RV9uj7625PYos2toHTAhNz8+LSssI2kbYBdgfYkxmZlZjTITwVJgiqTJkkYDs4COmjIdwAlp+jjgNxERJcZkZmY1SusaSn3+c4ElwCjgWxGxXNICYFlEdADfBC6W1AU8RJYstnRbRBfVFsTt8SK3RV9uj7622PaQ34CbmVWbv1lsZlZxTgRmZhVX+USQBrNvTLe5uCwNbBeVOzOVWSXpbbnlhbfRqFevpH+QdLOkjZKOG2TMkvQbSTs3iqHmOXVv5zGIfZubloWkMQ3iLKy3pky9diqMV9Iekq6W9LikC2rq+pWk3XLzO0j6b0mjJJ0g6c70OIECknaX9MtU5pe9daX2Pj/Fcrukg3PP+bmkhyVd1aAdCustKFcYo6RzJK2V9HhN+bmSTq633WYNYTvtJ+l6SU9L+mSD7b1O0h9Te54vbfol0np1SRot6bfKPmW4xat3fNeUqXtMD5uIqNwDGA3smKYvB2al6QuB/1FQfipwG7AdMBm4i2wAfFSa3ifVeRswtVG9wCTgQOAi4LhBxn8s8JU0XTeGmuf8T+DCND0LuGwz9u2gtB9rgDF1Yiyst6BcvXaqF++OwJuB04ALauo6ATgrN/8R4Axgd2B1+rtbmt6tIJYvAPPS9Dzg3DT9duBngIBDgRtzzzkSeCdwVYPXq7DemjJ1Y0zb3At4vOY5LwVuGYL/h6Fqp5cDhwDnAJ9ssL0/pH1SatdjCsrUrQv4DPCBoT4vDLLtNmmfZo7vmjJ1j+lh249WN+Qwv2j7A18C7iY7mYnsm37bpPVvAJYUPO9M4Mzc/JJUtk/53nLN1At8h8EngkuAw4vqro21NuY0vU2KTwPdt5o611A/ERTWW1OmbjvVizf33BNr/2nSyetPufnfkyWs2cDXcsu/BswuiHkVsFea3gtYVVQ+Xy7NH07jRFBYb02ZfmOkJhGkZVcC0zbz/2JI2im3/mzqJIJU/s/19rug/CZ1Aa8BOjdnn4fqQfYG5/vAEfnjs7/ju05dmxzTw/UY8V1DknaUdJKka4GvAyuAAyPiFrLbWTwcERtT8W6y217UKrpdxrgGy5utd7DeBNzUT2y1+tzOA+i9ncdA961ZzTy/UTvVi7euiNgAbJcutUcD+0TEmgHsyysi4r40fT/wigHsSyP16s0b7DaWAYcNIJY+hridmjEu1dvfNhr5E9nVwpZgX+BSYC6wQtK/SRqb1pV9HhgyW0U/22a6D7gd+FBE/LnVwQyR3SPisVYHsYV6ABhL9g31hwdbSUSEpCH/bHUJ9T4A7LcZzx/DFthO/WzzOUnPSNqp1f8HEfEccBVwlaQ24HPAvZLeSNa1tlUY8VcEZN9YXgf8SNJ8SfkbL60Hds0NPBXdBgPq3y6j3vJm6x2sjZJ6X7tmbuXRp5z63s5joPvWrGae36idBnv7ke2Bv6XH9gOIBeCvkvZK29yL7CQ7kOfXU6/evMFuo3d/B2so26kZ61K9/W2jP9sBTw3ieUNO0i6STiW7U8IU4GSyN59lnweGzIhPBBHxi4h4H9nl8yPAj9OnSyZF1jF3NVmygGyw8ccF1XQAs9InWSaTvdh/oM5tNAZQ72CtIhvEpV4Mdfah6HYeA9q3RkFJmibpotz2iup9QT/tNODbj6RPn+wJrEndRKMkbU823vBWSbulT7i8NS2rld9mbSzHp08PHQo8kusaqRfL5yT9Yz/15jUbY619ybpKBmWI26kuSb+WNC6126OSDk2v1/HNPL+mrj2AByPi2YE8rwySvgfcTPaBiOMj4i0RcVFEPDUM54Gh0+rBllY8yH4rYUKa3ofsBNUF/ADYLi2fASzIPecssoGhVeQ+5UD2iZI70rr8J1bq1XsIWV/hE2TvGJYPIv5/J+vq6i+GBcCMNL19iqMrxbXPZuzb6WkfNgJ/Ab6Rlh9H38HGevV2AmP7aadG8a4huyXJ4ymO3k8ztQM/zJX7JnBUmj451dUFnJQr8w2gPU3vAfwauBP4FVkXHGSDfgvTvvyxt3xa9zugh+yddTfwtrT8Kl4c7K5Xb3tv2/UT4xdS3c+nv2fn1t0M7LGZ/w9D1U57pvgeJetu6gZ2JnvDeQ+wQ26//5Ta8wJevMPBacBpjerKHWdfavV5JHee2KbB+mbPL4XH9HA9fIuJrVC6HL8oIo5udSx5kr4IXBwRt7do++eRXZH9Os0fDHwsIv65BbEsiYjC704M4TYOAj6+uftXdjtJOgA4OSI+PkT1/Yjs46t3DEV95nsNbbUkvRf4eUQ82upYthSSPhwRX69ZdjLw3cgG9UYUSUcDd0b2iZ/NrWuraKfebsqIuKjfwtY0JwIzs4ob8YPFZmbWmBOBmVnFORGYmVWcE4GZWcU5EZiZVdz/B+sXoKvjb+bHAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mean, variance = random_sample_supervised(circuit,loss_func, N=qubit_num, sample_num=SAMPLE, BATCH=BATCH, TRAIN_X=train_x, TRAIN_Y=train_y, mode='max')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "\n",
    "可训练性问题是目前量子神经网络的研究的一个核心方向，量桨提供的梯度分析工具支持用户对模型进行可训练性的诊断，便于贫瘠高原等问题的研究。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_______\n",
    "\n",
    "## 参考文献\n",
    "\n",
    "[1] McClean, J. R., Boixo, S., Smelyanskiy, V. N., Babbush, R. & Neven, H. Barren plateaus in quantum neural network training landscapes. [Nat. Commun. 9, 4812 (2018).](https://www.nature.com/articles/s41467-018-07090-4)\n",
    "\n",
    "[2] Cerezo, M., Sone, A., Volkoff, T., Cincio, L. & Coles, P. J. Cost-Function-Dependent Barren Plateaus in Shallow Quantum Neural Networks. [arXiv:2001.00550 (2020).](https://arxiv.org/abs/2001.00550)\n",
    "\n",
    "[3] Kieferova, Maria, Ortiz Marrero Carlos, and Nathan Wiebe. \"Quantum Generative Training Using R\\'enyi Divergences.\" arXiv preprint [arXiv:2106.09567 (2021).](https://arxiv.org/abs/2106.09567)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.13 ('pq')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  },
  "vscode": {
   "interpreter": {
    "hash": "1e82098cfee7be27b5e385e3f85fe91d734d6114f7d09dccafdaad2c23171c3e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
